home *** CD-ROM | disk | FTP | other *** search
/ The Fatted Calf / The Fatted Calf.iso / Applications / GraphicViewers / ViewGif2 / Source / Animator.m < prev    next >
Text File  |  1991-07-17  |  4KB  |  218 lines
  1.  
  2. /*
  3.  *  An 'Animator' controls the timing for your action method of choice.
  4.  *  The object may function as a general timer object; i.e.
  5.  *  graphics are neither expected nor required by the class.
  6.  *  When you create an Animator with +newChronon, you specify
  7.  *  the time interval between calls, the adaptation time constant (see below),
  8.  *  the target to which the method belongs, the action name, whether to 
  9.  *  automatically start up the timing upon creation, and an event mask (if you     
  10.  *  plan to break conditionally out of loops within the action method).
  11.  *
  12.  *  The Animator has adaptive means for adjusting to harsh operating
  13.  *  environments.  An adaptation constant d > 0. will invoke dynamical 
  14.  *  correction of entry times, on-the-fly, so that the desired chronon
  15.  *  will be realized in a real-time sense.
  16.  *
  17.  *  Functionality and applications are discussed in Report ETC-0008.
  18.  */
  19.  
  20. #import "Animator.h"
  21.  
  22. #import <appkit/Application.h>
  23. #import <sys/time.h>
  24. #import <objc/vectors.h>
  25.  
  26.  
  27. @implementation Animator
  28.  
  29. void timerFunction(teNum, now, self)
  30. DPSTimedEntry teNum;
  31. double now;
  32. Animator *self;
  33. {
  34.     gettimeofday(&self->entrytime, NULL);
  35.     if (self->howOften > 0.0) {
  36.     [self adapt];
  37.     }
  38.     
  39.     [self->target perform:self->action with:self];
  40. }
  41.  
  42. - initChronon:(double)dt    /* The time increment desired. */
  43.   adaptation:(double)howoft    /* Adaptive time constant (0.deactivates).*/
  44.   target:(id)targ        /* Target to whom proc belongs. */
  45.   action:(SEL)act        /* The action. */
  46.   autoStart:(int)start        /* Automatic start of timed entry? */
  47.   eventMask:(int)eMask        /* Mask for optional check in "shouldBreak". */
  48. {
  49.     [super init];
  50.     ticking = NO;
  51.     desireddt = dt;
  52.     [self setIncrement:dt];
  53.     [self setAdaptation:howoft];
  54.     [self setTarget:targ];
  55.     [self setAction:act];
  56.     
  57.     if (start) {
  58.     [self startEntry];
  59.     }
  60.     
  61.     mask = eMask;
  62.     [self resetRealTime];
  63.     
  64.     return self;
  65. }
  66.  
  67. - resetRealTime
  68. /* After this call, getDoubleRealTime is the real time that ensues. */
  69. { 
  70.     struct timeval    realtime;
  71.     
  72.     gettimeofday(&realtime, NULL);
  73.     synctime = realtime.tv_sec + realtime.tv_usec / 1000000.0;
  74.     passcounter = 0;
  75.     t0 = 0.0;
  76.     
  77.     return self;
  78. }
  79.  
  80. - (double)getSyncTime
  81. {
  82.     return synctime;
  83. }
  84.  
  85. - (double)getDoubleEntryTime
  86. /* Returns real time since "resetrealTime". */
  87. {
  88.     return (- synctime + entrytime.tv_sec + entrytime.tv_usec / 1000000.0);
  89. }
  90.  
  91. - (double)getDoubleRealTime
  92. /* Returns real time since "resetrealTime". */
  93. {
  94.     struct timeval    realtime;
  95.     struct timezone    tzone;
  96.     
  97.     gettimeofday(&realtime, &tzone);
  98.     return (- synctime + realtime.tv_sec + realtime.tv_usec / 1000000.0);
  99. }
  100.  
  101. - (double)getDouble
  102. {
  103.     return [self getDoubleRealTime];
  104. }
  105.  
  106. - adapt
  107. /* Adaptive time-step algorithm. */
  108. {
  109.     double t;
  110.     
  111.     if (!ticking) {
  112.     return self;
  113.     }
  114.     
  115.     ++passcounter;
  116.     t = [self getDoubleEntryTime];
  117.     
  118.     if (t - t0 >= howOften) {      
  119.     adapteddt *= desireddt * passcounter / (t - t0);
  120.     [self setIncrement:adapteddt];
  121.     [self startEntry];
  122.     passcounter = 0;
  123.     t0 = t;
  124.     }
  125.     return self;
  126. }
  127.   
  128. - setBreakMask:(int)eventMask
  129. {
  130.     mask = eventMask;
  131.     return self;
  132. }
  133.  
  134. - (int)getBreakMask
  135. {
  136.     return mask;
  137. }
  138.  
  139. - (int)isTicking
  140. {
  141.     return ticking;
  142. }
  143.    
  144. - (int)shouldBreak
  145. /* Call this to see if you want to exit a loop in your action method. */
  146. {
  147.     NXEvent    *e, event;
  148.     
  149.     e = [NXApp peekNextEvent:mask
  150.                into:&event
  151.            waitFor:0.0
  152.            threshold:NX_MODALRESPTHRESHOLD + 1];
  153.            
  154.     return (e ? 1: 0);
  155. }
  156.  
  157. - setIncrement:(double)dt
  158. {
  159.     adapteddt = dt;
  160.     interval = dt;
  161.   
  162.     return self;
  163. }
  164.  
  165. - (double)getIncrement
  166. {
  167.     return adapteddt;
  168. }
  169.  
  170. - setAdaptation:(double)oft
  171. {
  172.     howOften = oft;
  173.     return self;
  174. }
  175.  
  176. - setTarget:(id)targ
  177. {
  178.     target = targ;
  179.     return self;
  180. }
  181.  
  182. - setAction:(SEL)aSelector
  183. {
  184.     action = aSelector;
  185.     return self;
  186. }
  187.  
  188. - startEntry
  189. { 
  190.     [self stopEntry];
  191.     teNum = DPSAddTimedEntry(interval, &timerFunction, self,
  192.                      NX_MODALRESPTHRESHOLD+1);
  193.     ticking = YES;
  194.     
  195.     return self;
  196. }
  197.  
  198. - stopEntry
  199. {
  200.     if (ticking) {
  201.     DPSRemoveTimedEntry(teNum);
  202.     }
  203.     ticking = NO;
  204.     
  205.     return self;
  206. }
  207.  
  208. - free
  209. {
  210.     if (ticking) {
  211.     DPSRemoveTimedEntry(teNum);
  212.     }
  213.     
  214.     return [super free];
  215. }
  216.  
  217. @end    
  218.